<!DOCTYPE html>
<html lang="zh-cn">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>openGauss Blog  | openGauss数据库核心技术-SQL引擎（1）</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">

    
    <link rel="shortcut icon" href="https://xzx666.gitee.io/lookeng/img/favicon.ico" type="image/x-icon" />
    <link rel="apple-touch-icon" href="https://xzx666.gitee.io/lookeng/img/apple-touch-icon.png" />

    <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">

    
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">
    <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.js"></script>
    
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/commen.css?t=1607593672000" />
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/blog.css?t=1607593672000" />
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/mobile.css?t=1607593672000" />
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/pagination.css?t=1607593672000">
    
    <script>
      var _hmt = _hmt || [];
      (function() {
        var hm = document.createElement("script");
        hm.src = "https://hm.baidu.com/hm.js?34e9f585f29581007941aa1698181871";
        var s = document.getElementsByTagName("script")[0]; 
        s.parentNode.insertBefore(hm, s);
      })();
    </script>
</head>
<body>
  <script src="//cdn1.lncld.net/static/js/3.0.4/av-min.js"></script>
  <script src='//unpkg.com/valine/dist/Valine.min.js'></script>






<div class="container">
    <div class="columns blog-detail">
        <div class="post_detail">
            <div class="is-child box">
                <div class="breadCrumb"><a href="\zh\">博客/</a></div>
                <div class="blog-detail-header">
                    <h1>openGauss数据库核心技术-SQL引擎（1）</h1>
                    <div class="blog-detail-prop">
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-date.png">
                        <span class="article_right_date">2020-07-22</span>
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-author.png">
                        <span class="article_right_author">kangyang</span>
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-view.png">
                        <span id="/zh/post/kangyang/opengauss-sql-1-update/" class="leancloud_visitors" data-flag-title="openGauss数据库核心技术-SQL引擎（1）">
                            <i class="leancloud-visitors-count"></i>                     
                        </span>
                    </div>
                    <div class="blog-detail-tags">
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-tag.png">
                        
                        <a href="https://xzx666.gitee.io/lookeng/zh/tags/opengauss%E6%95%B0%E6%8D%AE%E5%BA%93%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF">openGauss数据库核心技术</a>
                        
                    </div>
                </div>
                <div class="content blog-content">
                    

<h3 id="前言">前言</h3>

<pre><code>openGauss是高斯数据库系列产品之一，其开源版本已在今年6月30日推出。接下来将以技术连载的方式陆续向大家介绍openGauss数据库的各项核心技术，包括SQL引擎、优化器、存储引擎、事务处理、数据库安全等。本期开始介绍openGauss SQL引擎技术。

数据库的SQL引擎是数据库重要的子系统之一，它对上负责承接应用程序发送过来的SQL语句，对下则负责指挥执行器运行执行计划。其中优化器作为SQL引擎中最重要、最复杂的模块，被称为数据库的“大脑”，优化器产生的执行计划的优劣直接决定数据库的性能。本文将从SQL语句进入数据库开始，对SQL引擎的各个模块进行全面的说明。
</code></pre>

<h3 id="1-sql引擎概览">1 SQL引擎概览</h3>

<hr />

<p>SQL引擎是数据库系统重要组成部分，它的主要职责是负责将应用程序输入的SQL在当前负载场景下生成高效的执行计划，在SQL的高效执行上扮演重要角色。SQL在SQL引擎里执行过程，如图1所示。</p>

<p><strong>图1  SQL执行流程</strong></p>

<p><img src="../figures/zh-cn_image_0262916291.png" alt="" /></p>

<p>从图1中可以看出，应用程序的SQL需要经过SQL解析生成逻辑执行计划、经过查询优化生成物理执行计划，然后将物理执行计划转交给查询执行引擎做物理算子的执行操作。</p>

<p>SQL解析通常包含词法分析、语法分析、语义分析几个子模块。SQL语言是介于关系演算和关系代数之间一种描述性语言，它吸取了关系代数中一部分逻辑算子的描述，而放弃了关系代数中“过程化”的部分，SQL解析主要的作用就是将一个SQL语句编译成为一个由关系算子组成的逻辑执行计划。</p>

<p>描述语言的特点是规定了需要获取的“WHAT”，而不关心“HOW”，也就是只关注结果而不关注过程，因此SQL语言描述性的特点导致查询优化在数据库管理系统中具有非常重要的作用。</p>

<p>查询重写则是在逻辑执行计划的基础上进行等价的关系代数变换，这种优化也可以称为代数优化，虽然两个关系代数式获得的结果完全相同，但是它们的执行代价却可能有很大的差异，这就构成了查询重写优化的基础。</p>

<p>在早期的数据库管理系统中，通常采用基于启发式规则的方法来生成最优的物理执行计划，但是这种基于规则的优化的灵活度不够，常常导致产生一些次优的执行计划，而代价估算的引入，则从根本上解决了基于规则优化的不足。</p>

<p>基于代价的优化器一方面生成“候选”的物理执行路径，另一方面对这些执行路径计算它们的执行代价，这样就建立了执行路径的筛选标准，从而能够通过比较代价而获得最优的物理执行计划。</p>

<h3 id="2-sql解析">2 SQL解析</h3>

<p>SQL语句在数据库管理系统中的编译过程符合编译器实现的常规过程，需要进行词法分析、语法分析和语义分析。</p>

<ul>
<li>词法分析：从查询语句中识别出系统支持的关键字、标识符、操作符、终结符等，每个词确定自己固有的词性。</li>
<li>语法分析：根据SQL语言的标准定义语法规则，使用词法分析中产生的词去匹配语法规则，如果一个SQL语句能够匹配一个语法规则，则生成对应的抽象语法树（Abstract Syntax Tree，AST）。</li>
<li>语义分析：对语法树（AST）进行有效性检查，检查语法树中对应的表、列、函数、表达式是否有对应的元数据，将抽象语法树转换为逻辑执行计划（关系代数表达式）。</li>
</ul>

<p>在SQL语言标准中，确定了SQL语言的关键字以及语法规则信息，SQL解析器在做词法分析的过程中会将一个SQL语句根据关键字信息以及间隔信息划分为独立的原子单位，每个单位以一个词的方式展现，例如如下SQL语句：</p>

<pre><code class="language-sql">SELECT w_name FROM warehouse WHERE w_no = 1;
</code></pre>

<p>可以划分的关键字、标识符、操作符、常量等原子单位，如表1所示。</p>

<p><strong>表1  词法分析的特征</strong></p>

<table border='1'><thead align="left"><tr id="row60232767"><th class="cellrowborder" valign="top" width="37.37373737373738%" id="mcps1.1.3.1.1"><p id="p47015983"><a name="p47015983"></a><a name="p47015983"></a><strong id="b20490669"><a name="b20490669"></a><a name="b20490669"></a>词性</strong></p>
</th>
<th class="cellrowborder" valign="top" width="62.62626262626263%" id="mcps1.1.3.1.2"><p id="p49131481"><a name="p49131481"></a><a name="p49131481"></a><strong id="b39530145"><a name="b39530145"></a><a name="b39530145"></a>内容</strong></p>
</th>
</tr>
</thead>
<tbody><tr id="row47825138"><td class="cellrowborder" valign="top" width="37.37373737373738%" headers="mcps1.1.3.1.1 "><p id="p48630964"><a name="p48630964"></a><a name="p48630964"></a><strong id="b35025494"><a name="b35025494"></a><a name="b35025494"></a>关键字</strong></p>
</td>
<td class="cellrowborder" valign="top" width="62.62626262626263%" headers="mcps1.1.3.1.2 "><p id="p18492804"><a name="p18492804"></a><a name="p18492804"></a><strong id="b32217513"><a name="b32217513"></a><a name="b32217513"></a>SELECT、FROM、WHERE</strong></p>
</td>
</tr>
<tr id="row21522166"><td class="cellrowborder" valign="top" width="37.37373737373738%" headers="mcps1.1.3.1.1 "><p id="p65573909"><a name="p65573909"></a><a name="p65573909"></a><strong id="b53294272"><a name="b53294272"></a><a name="b53294272"></a>标识符</strong></p>
</td>
<td class="cellrowborder" valign="top" width="62.62626262626263%" headers="mcps1.1.3.1.2 "><p id="p21868813"><a name="p21868813"></a><a name="p21868813"></a><strong id="b62601592"><a name="b62601592"></a><a name="b62601592"></a>w_name、warehouse、w_no</strong></p>
</td>
</tr>
<tr id="row26543418"><td class="cellrowborder" valign="top" width="37.37373737373738%" headers="mcps1.1.3.1.1 "><p id="p2533231"><a name="p2533231"></a><a name="p2533231"></a><strong id="b22799085"><a name="b22799085"></a><a name="b22799085"></a>操作符</strong></p>
</td>
<td class="cellrowborder" valign="top" width="62.62626262626263%" headers="mcps1.1.3.1.2 "><p id="p34786562"><a name="p34786562"></a><a name="p34786562"></a><strong id="b44643603"><a name="b44643603"></a><a name="b44643603"></a>=</strong></p>
</td>
</tr>
<tr id="row66248115"><td class="cellrowborder" valign="top" width="37.37373737373738%" headers="mcps1.1.3.1.1 "><p id="p64497130"><a name="p64497130"></a><a name="p64497130"></a><strong id="b43603258"><a name="b43603258"></a><a name="b43603258"></a>常量</strong></p>
</td>
<td class="cellrowborder" valign="top" width="62.62626262626263%" headers="mcps1.1.3.1.2 "><p id="p42202994"><a name="p42202994"></a><a name="p42202994"></a><strong id="b44282627"><a name="b44282627"></a><a name="b44282627"></a>1</strong></p>
</td>
</tr>
</tbody>
</table>

<p>语法分析会根据词法分析获得的词来匹配语法规则，最终生成一个抽象语法树（AST），每个词作为语法树的叶子结点出现，如图2所示。</p>

<p><strong>图2  抽象语法树</strong></p>

<p><img src="../figures/zh-cn_image_0262916293.png" alt="" /></p>

<p>抽象语法树表达的语义还仅仅限制在能够保证应用的SQL语句符合SQL标准的规范，但是对于SQL语句的内在含义还需要做有效性的检查。</p>

<ul>
<li>检查关系的使用：FROM子句中出现的关系必须是该查询对应模式中的关系或视图。</li>
<li>检查与解析属性的使用：在SELECT句中或者WHERE子句中出现的各个属性必须是FROM子句中某个关系或视图的属性。</li>
<li>检查数据类型：所有属性的数据类型必须是匹配的。</li>
</ul>

<p>在有效性检查的同时，语义分析的过程还是有效性语义绑定（Bind）的过程，通过语义分析的检查，抽象语法树就转换成一个逻辑执行计划，逻辑执行计划可以通过关系代数表达式的形式来表现，如图3所示。</p>

<p><strong>图3  关系代数表达式</strong></p>

<p><img src="../figures/zh-cn_image_0262916295.png" alt="" /></p>

<h3 id="3-查询优化">3 查询优化</h3>

<p>SQL语句在编写的过程中，数据库应用开发人员通常会考虑以不同的形式来编写SQL，来达到提升执行性能的目的，那么为什么还需要查询优化器来对SQL进行优化呢？这是因为一个应用程序可能会涉及到大量的SQL语句，而且有些SQL语句的逻辑极为复杂，数据库开发人员很难面面俱到的写出高性能语句，而查询优化器则具有一些独特的优势：</p>

<ul>
<li><p>查询优化器和数据库应用程序开发人员之间的信息不对称，查询优化器在优化的过程中会参考数据库统计模块自动产生的统计信息，这些统计信息从各个角度来描述数据的分布情况，查询优化器会综合考虑统计信息中的各种数据，从而能够得到一个比较好的执行方案，而数据库用户一方面无法全面的了解数据的分布情况，另一方面也很难通过统计信息构建一个精确的代价模型来对执行计划进行筛选。</p></li>

<li><p>查询优化器和数据库应用程序开发人员之间的时效性不同，数据库中的数据瞬息万变，一个在A时间点执行性能很高的执行计划，在B时间点由于数据内容发生了变化，它的性能可能就很低，查询优化器则随时都能根据数据的变化调整执行计划，而数据库应用程序开发人员则只能手动的调整SQL语句，和查询优化器相比，它的时效性比较低。</p></li>

<li><p>查询优化器和数据库应用程序开发人员的计算能力不同，目前计算机的计算能力已经大幅提高，在执行数值计算方面和人脑相比具有巨大的优势，查询优化器对一个SQL语句进行优化时，可以从成百上千个执行方案中选择一个最优方案，而人脑要计算这几百种方案需要的时间要远远长于计算机。</p></li>
</ul>

<p>因此，查询优化器是提升查询效率的非常重要的一个手段，虽然一些数据库也提供了人工干预执行计划生成的方法，但是通常而言，查询优化器的优化过程对数据库开发人员是透明的，它自动进行逻辑上的等价变换、自动进行物理执行计划的筛选，极大的提高了数据库应用程序开发人员的“生产力”。</p>

<p>依据优化方法的不同，优化器的优化技术可以分为：</p>

<ul>
<li><p>基于规则的查询优化（Rule Based Optimization，RBO）：根据预定义的启发式规则对SQL语句进行优化。</p></li>

<li><p>基于代价的查询优化（Cost Based Optimization，CBO）：对SQL语句对应的待选执行路径进行代价估算，从待选路径中选择代价最低的执行路径作为最终的执行计划。</p></li>

<li><p>基于机器学习的查询优化（AI Based Optimization，ABO）：收集执行计划的特征信息，借助机器学习模型获得经验信息，进而对执行计划进行调优，获得最优的执行计划。</p></li>
</ul>

<p>在早期的数据库中，查询优化器通常采用启发式规则进行优化，这种优化方式不不够灵活，往往难以获得最优的执行代价，而基于代价的优化则能够针对大多数场景都高效筛选出性能较好的执行计划，但面对用户千人千面，日趋复杂的实际查询场景，普适性的查询优化由于难以捕捉到用户特定的查询需求、数据分布、硬件性能等特征，难以全方位满足实际的优化需求。</p>

<p>近年来AI技术，特别是在深度学习领域，发展迅速，基于机器学习的优化器在建模效率、估算准确率和自适应性等方面都有很大优势，有望打破RBO和CBO基于静态模型的限制，通过对历史经验的不断学习，将目标场景的模式进行抽象化，形成动态的模型，自适应地针对用户的实际场景进行优化。openGauss采用基于CBO的优化技术，另外在ABO方面也在进行积极探索。</p>

<h4 id="3-1-查询重写"><strong>3.1 查询重写</strong></h4>

<p>查询重写利用已有语句特征和关系代数运算来生成更高效的等价语句，在数据库优化器中扮演关键角色，尤其在复杂查询中，能够在性能上带来数量级的提升，可谓是“立竿见影”的“黑科技”。本节介绍查询重写的基本概念、常见的查询重写技术、查询重写面临的挑战。</p>

<h5 id="查询重写的概念">查询重写的概念</h5>

<p>SQL语言是丰富多样的，非常的灵活，不同的开发人员依据经验的不同，手写的SQL语句也是各式各样，另外还可以通过工具自动生成。SQL语言是一种描述性语言，数据库的使用者只是描述了想要的结果，而不关心数据的具体获取方式，输入数据库的SQL语言很难做到是以最优形式表示的，往往隐含了一些冗余信息，这些信息可以被挖掘用来生成更加高效的SQL语句。查询重写就是把用户输入的SQL语句转换为更高效的等价SQL，查询重写遵循两个基本原则：</p>

<ul>
<li><p>等价性：原语句和重写后的语句，输出结果相同。</p></li>

<li><p>高效性：重写后的语句，比原语句在执行时间和资源使用上更高效。</p></li>
</ul>

<h5 id="关系代数等价变换">关系代数等价变换</h5>

<p>查询重写主要是基于关系代数式的等价变换，关系代数的变换通常满足交换律、结合律、分配率、串接率等，如表2所示。</p>

<p><strong>表2  关系代数等价变换</strong></p>

<p><a name="table13886291122"></a></p>

<table border='1'><tbody><tr id="row192243291224"><td class="cellrowborder" valign="top" width="34%"><p id="p142241294218"><a name="p142241294218"></a><a name="p142241294218"></a>等价变换</p>
</td>
<td class="cellrowborder" valign="top" width="82.89999999999999%"><p id="p82248294216"><a name="p82248294216"></a><a name="p82248294216"></a>内容</p>
</td>
</tr>
<tr id="row182245291421"><td class="cellrowborder" valign="top" width="17.1%"><p id="p1222416296215"><a name="p1222416296215"></a><a name="p1222416296215"></a>交换律</p>
</td>
<td class="cellrowborder" valign="top" width="82.89999999999999%"><p id="p62247298218"><a name="p62247298218"></a><a name="p62247298218"></a>A × B == B × A</p>
<p id="p1224142917211"><a name="p1224142917211"></a><a name="p1224142917211"></a>A ⨝B == B ⨝ A</p>
<p id="p122414292211"><a name="p122414292211"></a><a name="p122414292211"></a>A ⨝F B == B ⨝F A &nbsp &nbsp &nbsp           -- F是连接条件</p>
<p id="p622418299218"><a name="p622418299218"></a><a name="p622418299218"></a>Π p(σF (B)) == σF (Π p(B))   &nbsp &nbsp &nbsp   –- F∈p</p>
</td>
</tr>
<tr id="row822402912213"><td class="cellrowborder" valign="top" width="17.1%"><p id="p222414291224"><a name="p222414291224"></a><a name="p222414291224"></a>结合律</p>
</td>
<td class="cellrowborder" valign="top" width="82.89999999999999%"><p id="p1224529524"><a name="p1224529524"></a><a name="p1224529524"></a>(A × B) × C==A × (B × C)</p>
<p id="p82247293212"><a name="p82247293212"></a><a name="p82247293212"></a>(A ⨝ B) ⨝ C==A ⨝ (B ⨝ C)</p>
<p id="p112241229829"><a name="p112241229829"></a><a name="p112241229829"></a>(A ⨝F1 B) ⨝F2 C==A ⨝F1 (B ⨝F2 C)  &nbsp &nbsp &nbsp  -- F1和F2是连接条件</p>
</td>
</tr>
<tr id="row16224192912218"><td class="cellrowborder" valign="top" width="17.1%"><p id="p222419298219"><a name="p222419298219"></a><a name="p222419298219"></a>分配律</p>
</td>
<td class="cellrowborder" valign="top" width="82.89999999999999%"><p id="p4224629128"><a name="p4224629128"></a><a name="p4224629128"></a>σF(A × B) == σF(A) × B -- F ∈ A</p>
<p id="p9224129328"><a name="p9224129328"></a><a name="p9224129328"></a>σF(A × B) == σF1(A) × σF2(B) &nbsp &nbsp &nbsp      -- F = F1 ∪ F2，F1∈A, F2 ∈B</p>
<p id="p2022482911211"><a name="p2022482911211"></a><a name="p2022482911211"></a>σF(A × B) == σFX (σF1(A) × σF2(B)) &nbsp &nbsp &nbsp -- F = F1∪F2∪FX，F1∈A, F2 ∈B</p>
<p id="p1322462918217"><a name="p1322462918217"></a><a name="p1322462918217"></a>Π p,q(A × B) == Π p(A) × Π q(B) &nbsp &nbsp &nbsp -- p∈A，q∈B</p>
<p id="p622420297218"><a name="p622420297218"></a><a name="p622420297218"></a>σF(A × B) == σF1(A) × σF2(B)  &nbsp &nbsp &nbsp -- F = F1 ∪ F2，F1∈A, F2 ∈B</p>
    <p id="p5224122911216"><a name="p5224122911216"></a><a name="p5224122911216"></a>σF(A × B) == σFx (σF1(A) × σF2(B)) &nbsp &nbsp &nbsp -- 其中F = F1∪F2∪Fx，F1∈A, F2 ∈B</p>
</td>
</tr>
<tr id="row72249295212"><td class="cellrowborder" valign="top" width="17.1%"><p id="p1522462920218"><a name="p1522462920218"></a><a name="p1522462920218"></a>串接律</p>
</td>
<td class="cellrowborder" valign="top" width="82.89999999999999%"><p id="p10225429429"><a name="p10225429429"></a><a name="p10225429429"></a>Π P=p1,p2,…pn(Π Q=q1,q2,…qn(A)) == Π P=p1,p2,…pn(A) -- P ⊆ Q</p>
<p id="p522518297211"><a name="p522518297211"></a><a name="p522518297211"></a>σF1(σF2(A)) == σF1∧F2(A)</p>
</td>
</tr>
</tbody>
</table>

<p>表2中的等价变换规则并不能把所有的情况都列举出来，例如，如果对<code>σF1(σF2(A)) == σF1∧F2(A)</code>继续推导，那么就可以获得：</p>

<pre><code>σF1(σF2(A)) == σF1∧F2(A) == σF2∧F1(A) == σF2(σF1(A))
</code></pre>

<p>因此，在熟悉了关系代数的操作之后，就可以灵活的利用关系代数的等价关系进行推导，获得更多的等价式。这些等价的变换一方面可以用来根据启发式的规则做优化，这样能保证等价转换之后的关系代数表达式的执行效率能够获得提高而非降低，例如借助分配率可以将一个选择操作下推，这样能降低上层结点的计算量，另一方面还可以用来生成候选的执行计划，候选的执行计划再由优化器根据估算的代价进行筛选。</p>

<h5 id="常见的查询重写技术">常见的查询重写技术</h5>

<p>介绍下openGauss几个关键的查询重写技术：常量表达式化简、子查询优化、选择下推和等价推理等。</p>

<ol>
<li>常量表达式化简</li>
</ol>

<p>常量表达式即用户输入SQL语句中包含运算结果为常量的表达式，分为算数表达式、逻辑运算表达式、函数表达式，查询重写可以对常量表达式预先计算以提升效率。例如：</p>

<p><strong>示例1</strong>：该语句为典型的算数表达式查询重写，经过重写之后，避免了在执行时每条数据都需要进行1+1运算。</p>

<pre><code class="language-sql">SELECT * FROM t1 WHERE c1 = 1+1;
SELECT * FROM t1 WHERE c1 = 2;
</code></pre>

<p><strong>示例2</strong>：该语句为典型的逻辑运算表达式，经过重写之后，条件永远为false，可以直接返回0行结果，避免了整个语句的实际执行。</p>

<pre><code class="language-sql">SELECT * FROM t1 WHERE  1=0  AND a=1;
SELECT * FROM t1 WHERE  false;
</code></pre>

<p><strong>示例3</strong>：该语句包含函数表达式，由于函数的入参为常量，经过重写之后，直接把函数运算结果在优化阶段计算出来，避免了在执行过程中逐条数据的函数调用开销。</p>

<pre><code class="language-sql">SELECT * FROM t1 WHERE c1 =  ADD(1,1);
SELECT * FROM t1 WHERE c1 =  2;
</code></pre>

<ol>
<li>子查询优化</li>
</ol>

<p>由于子查询表示的结构更清晰，符合人的阅读理解习惯，用户输入的SQL语句往往包含了大量的子查询。子查询有几种分类方法，根据子查询是否可以独立求解，分为相关子查询和非相关子查询。</p>

<ul>
<li><p>相关子查询：相关子查询是指子查询中有依赖父查询的条件，例如：</p>

<pre><code class="language-sql">SELECT * FROM t1 WHERE EXISTS (SELECT t2.c1 FROM t2 WHERE t1.c1=t2.c1);
</code></pre></li>
</ul>

<p>​       语句中子查询依赖父查询传入t1.c1的值。</p>

<ul>
<li><p>非相关子查询：非相关子查询是指子查询不依赖父查询，可以独立求解，例如：</p>

<pre><code class="language-sql">SELECT * FROM t1 WHERE EXISTS (SELECT t2.c1 FROM t2);
</code></pre></li>
</ul>

<p>语句中子查询没有依赖父查询的条件。</p>

<p>​       其中，相关子查询需要父查询执行出一条结果，然后驱动子查询运算，这种嵌套循环的方式执行效率较低。如果能把子查询提升为父查询同级别，那么可以子查询中的表就能和父查询中的表直接做Join操作，由于Join操作可以有多种实现方法，优化器就可以从多种实现方法中选择最优的一种，就有可能提高查询的执行效率，另外优化器还能够应用Join Reorder优化规则对不同的表的连接顺序进行交换，进而有可能产生更好的执行计划。</p>

<p><strong>示例4</strong>：该语句为典型的子查询提升重写，重写之后利用Hash Join可以提升查询性能。</p>

<pre><code class="language-sql">SELECT * FROM t1 WHERE t1.c1 IN (SELECT t2.c1 FROM t2);
SELECT * FROM t1 Semi Join t2 ON t1.c1 = t2.c1;
</code></pre>

<ol>
<li>选择的下推和等价推理</li>
</ol>

<p>选择的下推能够极大的降低上层算子的计算量，从而达到优化的效果，如果选择条件有存在等值操作，那么还可以借助等值操作的特性来实现等价推理，从而获得新的选择条件。</p>

<p>例如，假设有两个表t1、t2分别包含[1,2,3,..100]共100行数据，那么查询语句</p>

<pre><code class="language-sql">SELECT t1.c1, t2.c1 FROM t1 JOIN t2 ON t1.c1=t2.c1 WHERE t1.c1=1;
</code></pre>

<p>则可以通过选择下推和等价推理进行优化，如图4。</p>

<p><strong>图4  查询重写前后对比图</strong></p>

<p><img src="../figures/zh-cn_image_0263539505.png" alt="" /></p>

<p>如图4-（1）所示，t1、t2表都需要全表扫描100行数据，然后再做Join，生成100行数据的中间结果，最后再做选择操作，最终结果只有1行数据。如果利用等价推理，我们可以得到<code>{t1.c1, t2.c1, 1}</code>的是互相等价的，从而推导出新的<code>t2.c1=1</code>的选择条件，并把这个条件下推到t2上，从而得到图4-（4）重写之后的逻辑计划。可以看到，重写之后的逻辑计划，只需要从基表上面获取1条数据即可，Join时内、外表的数据也只有1条，同时省去了在最终结果上的过滤条件，性能大幅提升。</p>

<ol>
<li>外连接消除</li>
</ol>

<p>外连接和内连接的主要区别是对于不能产生连接结果的元组需要补NULL值，如果SQL语句中有过滤条件符合空值拒绝的条件（即会将补充的NULL值再过滤掉），则可以直接消除外连接。</p>

<p><strong>示例5</strong>：外连接转成内连接之后，便于优化器应用更多的优化规则，提高执行效率。</p>

<pre><code class="language-sql">SELECT * FROM t1  FULL JOIN t2 ON t1.c1 = t2.c1 WHERE t1.c2 &gt; 5 AND t2.c3 &lt; 10;
SELECT * FROM t1  INNER JOIN  t2 ON t1.c1 = t2.c2 WHERE t1.c2 &gt; 5 AND t2.c3 &lt; 10;
</code></pre>

<ol>
<li>DISTINCT消除</li>
</ol>

<p>DISTINCT列上如果有主键约束，则此列不可能为空，且无重复值，因此不需要DISTINCT操作，减少计算量。</p>

<p><strong>示例6</strong>：c1列上有的主键属性决定了无需做DISTINCT操作。语句如下：</p>

<pre><code class="language-sql">CREATE TABLE t1(c1 INT PRIMARY KEY, c2 INT);
SELECT  DISTINCT(c1) FROM t1;
SELECT c1 FROM t1;
</code></pre>

<ol>
<li>IN谓词展开</li>
</ol>

<p><strong>示例7</strong>：将IN操作符改写成等值的过滤条件，便于借助索引减少计算量。语句如下：</p>

<pre><code class="language-sql">SELECT * FROM t1 WHERE  c1 IN (10,20,30);
SELECT * FROM t1 WHERE  c1=10 or c1=20 OR c1=30;
</code></pre>

<ol>
<li>视图展开</li>
</ol>

<p>视图从逻辑上可以简化书写SQL的难度，提高查询的易用性，而视图本身是虚拟的，因此在查询重写的过程中，需要对视图展开。</p>

<p><strong>示例8</strong>：可以将视图查询重写成子查询的形式，然后再对子查询做简化。语句如下：</p>

<pre><code class="language-sql">CREATE VIEW v1 AS (SELECT * FROM t1,t2 WHERE t1.c1=t2.c2);
SELECT * FROM v1;
SELECT * FROM (SELECT * FROM t1,t2 WHERE t1.c1=t2.c2) as v1;
SELECT * FROM t1,t2 WHERE t1.c1=t2.c2;
</code></pre>

                </div>
            </div>
            <div class="box" style="margin-top:15px;">
                <div style="font-size:14px;color:gray"><strong>【免责声明】</strong>本文仅代表作者本人观点，与本网站无关。本网站对文中陈述、观点判断保持中立，不对所包含内容的准确性、可靠性或完整性提供任何明示或暗示的保证。本文仅供读者参考，由此产生的所有法律责任均由读者本人承担。</div>
            </div>
            <div class="post-comment">
                
                  
  <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/custom.css" />
  <div id="vcomments" lang="zh-cn" mess="说点什么吧..."></div>

  <script type="text/javascript">
    const placeholder = document.getElementById("vcomments").getAttribute("mess"),
          lang = document.getElementById("vcomments").getAttribute("lang");
    const  langs = lang == "zh-cn" ? "zh-cn" : "en";
    new Valine({
        el: '#vcomments' ,
        appId: '6wfgavgIRqmpC3hjHqQVtFWF-gzGzoHsz',
        appKey: 'QRqrBDBB0p0YhrGe9IJ169ip',
        avatar:'mm', 
        placeholder: placeholder,
        visitor: true,
		    meta: ['nick','mail','link'],
        lang: langs
    });
  </script>
            </div>
        </div>
    </div>
</div>
<script>
    $(function (){
        var query = new AV.Query('Counter');
        query.equalTo('url', decodeURIComponent('\/zh\/post\/kangyang\/opengauss-sql-1-update\/'));
        query.find().then(function (data) {
            if(data.length && (data[0].attributes.author === 'openGauss')){
                var counter = AV.Object.createWithoutData('Counter', data[0].id);
                counter.set('author', 'kangyang');
                counter.save();
            }
        })
    })
</script>







<input id="iframeUrl" type="text" style="display: none;" value=https://xzx666.gitee.io/>




<script defer src="https://xzx666.gitee.io/lookengjs/all.js"></script>
<script src="https://xzx666.gitee.io/lookengjs/flexible.js"></script>
<script>
  const hash = window.location.search,
        pageurl = window.location.href;
  var langss = document.querySelector("html").lang === "zh-cn" ? "zh" : "en";
  console.log("hash:",hash,"pageurl:",pageurl,"ttr",pageurl.split(langss + "/")[1])

  if(!document.getElementById("vcomments")) {
    new Valine({
        appId: '6wfgavgIRqmpC3hjHqQVtFWF-gzGzoHsz',
        appKey: 'QRqrBDBB0p0YhrGe9IJ169ip',
        avatar:'mm',
        visitor: true,
		    meta: ['nick','mail','link']
    });
  }
 
  
    


    const url = document.getElementById("iframeUrl").value;

    function observe (el, options, callback) {
      var MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver
      var observer = new MutationObserver(callback)
      observer.observe(el, options)
    }

    var options = {
        childList: true,
        subtree: true,
        characterData: true
      }
    observe(document.body, options, (records, instance) => {
    const height = document.body.scrollHeight;
    parent.postMessage(height,url);
    })
    if(pageurl.split(langss + "/")[1]) parent.postMessage(pageurl.split(langss + "/")[1],url);
    

    if(document.querySelector("#notFound")) parent.postMessage("我404了",url);

</script>
</body>
</html>
